package com.clf.data.redis.core.json.ops.impl;

import com.clf.data.redis.core.json.FastJsonRedisTemplate;
import com.clf.data.redis.core.json.ops.FastJsonBoundSetOperations;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.ScanOptions;

import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * ops覆盖类，可提供原先ops没有的方法
* @author <a href="mailto:zhudelie@zuozh.com">zhudelie</a>
* @version 
* @since JDK 1.6
* create on 2017年3月31日
* Copyright 2017 ZZJR All Rights Reserved.
*
*/
public class FastJsonBoundSetOperationsImpl<K,V> extends OperationsAware<K, V> implements FastJsonBoundSetOperations<K,V> {
	private BoundSetOperations<K,V> ops;
	public FastJsonBoundSetOperationsImpl(BoundSetOperations<K,V> ops, FastJsonRedisTemplate<K,V> template){
		super(template);
		this.ops = ops;
	}
	
	
	private BoundSetOperations<K,V> getOps(){
		return ops;
	}
	@Override
	public K getKey() {
		// TODO Auto-generated method stub
		return (K) getOps().getKey();
	}

	@Override
	public DataType getType() {
		// TODO Auto-generated method stub
		return getOps().getType();
	}

	@Override
	public Long getExpire() {
		// TODO Auto-generated method stub
		return getOps().getExpire();
	}

	@Override
	public Boolean expire(long timeout, TimeUnit unit) {
		// TODO Auto-generated method stub
		return getOps().expire(timeout, unit);
	}

	@Override
	public Boolean expireAt(Date date) {
		// TODO Auto-generated method stub
		return getOps().expireAt(date);
	}

	@Override
	public Boolean persist() {
		// TODO Auto-generated method stub
		return getOps().persist();
	}

	@Override
	public void rename(K newKey) {
		getOps().rename(newKey);
	}


	@Override
	public Long add(V ... values) {
		// TODO Auto-generated method stub
		return getOps().add(values);
	}

	@Override
	public Long remove(Object... values) {
		// TODO Auto-generated method stub
		return getOps().remove(values);
	}
	/**
	 * 随机删除并返回一个元素
	 */
	@Override
	public V pop() {
		// TODO Auto-generated method stub
		return (V) getOps().pop();
	}
	/**
	 * 将 member 元素从 source 集合移动到 destination 集合。
	 */
	@Override
	public Boolean move(K destKey, V value) {
		// TODO Auto-generated method stub
		return getOps().move(destKey, value);
	}
	/**
	 * 数量
	 */
	@Override
	public Long size() {
		// TODO Auto-generated method stub
		return getOps().size();
	}
	/**
	 * 是否为集合中的一个元素
	 */
	@Override
	public Boolean isMember(Object o) {
		// TODO Auto-generated method stub
		return getOps().isMember(o);
	}
	/**
	 * 与给定所有给定key的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)
	 */
	@Override
	public Set<V> intersect(K key) {
		// TODO Auto-generated method stub
		return getOps().intersect(key);
	}
	/**
	 * 给定所有给定集合的交集。 不存在的集合 key 被视为空集。 当给定集合当中有一个空集时，结果也为空集(根据集合运算定律)
	 */
	@Override
	public Set<V> intersect(Collection<K> keys) {
		// TODO Auto-generated method stub
		return getOps().intersect(keys);
	}
	/**
	 * 命令将给定集合之间的交集存储在指定的key中。如果指定的key已经存在，则将其覆盖。
	 */
	@Override
	public void intersectAndStore(K key, K destKey) {
		getOps().intersectAndStore(key, destKey);
	}
	/**
	 * 命令将给定集合之间的交集存储在指定的key中。如果指定的key已经存在，则将其覆盖。
	 */
	@Override
	public void intersectAndStore(Collection<K> keys, K destKey) {
		getOps().intersectAndStore(keys, destKey);
	}
	/**
	 * 命令返回给定集合的并集。不存在的集合 key 被视为空集。
	 */
	@Override
	public Set<V> union(K key) {
		// TODO Auto-generated method stub
		return getOps().union(key);
	}
	/**
	 * 命令返回给定集合的并集。不存在的集合 key 被视为空集。
	 */
	@Override
	public Set<V> union(Collection<K> keys) {
		// TODO Auto-generated method stub
		return getOps().union(keys);
	}
	/**
	 * 命令返回给定集合的并集并储存在指定key中。如果指定的key已经存在，则将其覆盖。
	 */
	@Override
	public void unionAndStore(K key, K destKey) {
		getOps().unionAndStore(key, destKey);
	}
	/**
	 * 命令返回给定集合的并集并储存在指定key中。如果指定的key已经存在，则将其覆盖。
	 */
	@Override
	public void unionAndStore(Collection<K> keys, K destKey) {
		getOps().unionAndStore(keys, destKey);
	}
	/**
	 * 命令返回给定集合之间的差集。不存在的集合 key 将视为空集
	 */
	@Override
	public Set<V> diff(K key) {
		// TODO Auto-generated method stub
		return getOps().diff(key);
	}
	/**
	 * 命令返回给定集合之间的差集。不存在的集合 key 将视为空集
	 */
	@Override
	public Set<V> diff(Collection<K> keys) {
		// TODO Auto-generated method stub
		return getOps().diff(keys);
	}
	/**
	 * 命令返回给定集合之间的差集并存在指定key中。如果指定的key已经存在，则将其覆盖。
	 */
	@Override
	public void diffAndStore(K keys, K destKey) {
		getOps().diffAndStore(keys, destKey);
	}
	/**
	 * 命令返回给定集合之间的差集并存在指定key中。如果指定的key已经存在，则将其覆盖。
	 */
	@Override
	public void diffAndStore(Collection<K> keys, K destKey) {
		getOps().diffAndStore(keys, destKey);
	}
	/**
	 * 获得所有元素
	 */
	@Override
	public Set<V> members() {
		// TODO Auto-generated method stub
		return getOps().members();
	}
	/**
	 * 随意获得一个集合元素
	 */
	@Override
	public V randomMember() {
		// TODO Auto-generated method stub
		return (V) getOps().randomMember();
	}
	/**
	 *  随机获取count个不重复的元素
	 */
	@Override
	public Set<V> distinctRandomMembers(long count) {
		// TODO Auto-generated method stub
		return getOps().distinctRandomMembers(count);
	}
	/**
	 *  随机获取count个元素
	 */
	@Override
	public List<V> randomMembers(long count) {
		// TODO Auto-generated method stub
		return getOps().randomMembers(count);
	}

	@Override
	public Cursor<V> scan(ScanOptions options) {
		// TODO Auto-generated method stub
		return getOps().scan(options);
	}


}
